perf(lsp): parse-pipeline hardening — immutable docs, partial-result cache, cancellation, workspace pruning - #9

While a document is mid-edit and fails to parse, parseDocument cleared the cached result. Navigation then re-parsed the same invalid buffer on every request (parsePathForNavigation re-parses when the cache is empty) and produced the identical best-effort AST — so clearing bought nothing but repeated work (audit I3).

Cache the partial result (Root is populated even on parse errors) so definition/hover/completion reuse it instead of re-parsing per request. Diagnostics are unaffected — they still come from result.Errors. Repurposed the existing valid-to-invalid test to pin the retained-partial behavior.

Handlers ignored ctx entirely, so a client $/cancelRequest cancelled nothing and a long import-chasing parse always ran to completion (audit I6).

- Parser.Parse takes a context and checks it before each (recursive) parse, so a cancelled or superseded request stops walking the import graph promptly.

- The diagnostics path (parseDocument, importDiagnostics) threads the request ctx through.

- parsePathForNavigation deliberately keeps using context.Background(): it is a fast single-file parse, and threading ctx through the resolution-callback layer would be high-churn for negligible benefit. The workspace-walk cancellation (the other heavy path) is handled in the I7 commit.

find-references, workspace-symbols, and missing-import quick-fixes scan the workspace root synchronously on the request. The scan descended into every directory and swallowed walk errors (audit I7), so on a monorepo it walked .git/node_modules/vendor for nothing and a transient FS error silently truncated results while looking complete.

- Prune .git, node_modules, vendor, and hidden directories (they never hold project schemas).

- Log unreadable entries and an incomplete walk via the server logger instead of discarding the error.

Deferred (needs broader plumbing / file-watching, tracked with I2): threading request cancellation into the walk and a cached, watch-invalidated path index.

Every caller ignores the bool, so it was dead surface. Removing it also drops the lone what-comment from the godoc, leaving only the why.

After I6 threaded a cancellable ctx into the parser, a cancelled or superseded request made Parse return ctx.Err(), which parseDocument turned into a bogus line-1 "context canceled" diagnostic and cached a nil result — clobbering the document's real diagnostics mid-edit. Found in self-review.

Treat a context error as stop, not failure: parseDocument returns no diagnostics and leaves the cache intact, and parseAndPublishDiagnostics skips publishing when the request is already cancelled.

The version-mismatch drop path is the reason SetResult takes a version, but no test exercised it. Add unit tests for the stale-version drop and the gone-document no-op.

Codex adversarial review found two gaps in the initial cancellation fix:

- Import recursion (buildPartialSchema) swallows ctx.Canceled as a skipped import, so Parse can return err==nil with an incomplete result after a cancel. parseDocument only checked ctx in the err\!=nil branch, so it cached that incomplete result. Move the ctx guard above the result handling so a cancelled request never caches or publishes.

- importDiagnostics threaded ctx but still called parsePathForNavigation, which uses context.Background(), leaking cancellation on the transitive-reimport path. Extract a ctx-aware parsePath (parsePathForNavigation now delegates to it with Background) and use it from importDiagnostics.

Codex follow-up on I2: importDiagnostics still reached the background parser via uniqueImportCandidatePath, which scans and parses every workspace candidate. Thread ctx into uniqueImportCandidatePath — it now bails when the request is cancelled and parses candidates with the request ctx. The diagnostics caller passes the real ctx; interactive code-action callers pass context.Background(), consistent with parsePathForNavigation.